home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 2 / Apprentice-Release2.iso / Source Code / Mark Pilgrim / Dialectic 1.2 / source / Dialectic ƒ / Raw dialects ƒ / Olde.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-10-30  |  10.4 KB  |  483 lines  |  [TEXT/KAHL]
  1. /**********************************************************************\
  2.  
  3. File:        Olde.c
  4.  
  5. Purpose:    This module handles actually converting text into Olde talk.
  6.  
  7.  
  8. Dialectic -=- dialect text conversion extraordinare
  9. Copyright ©1994, Mark Pilgrim
  10.  
  11. This program is free software; you can redistribute it and/or modify
  12. it under the terms of the GNU General Public License as published by
  13. the Free Software Foundation; either version 2 of the License, or
  14. (at your option) any later version.
  15.  
  16. This program is distributed in the hope that it will be useful,
  17. but WITHOUT ANY WARRANTY; without even the implied warranty of
  18. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19. GNU General Public License for more details.
  20.  
  21. You should have received a copy of the GNU General Public License
  22. along with this program in a file named "GNU General Public License".
  23. If not, write to the Free Software Foundation, 675 Mass Ave,
  24. Cambridge, MA 02139, USA.
  25.  
  26. \**********************************************************************/
  27.  
  28. #include "dialectic dispatch.h"
  29. #include "dialectic utilities.h"
  30. #include "program globals.h"
  31.  
  32. void ConvertOlde(void)
  33. {
  34.     char            oneChar;
  35.     
  36.     if (!IsAlpha(ThisChar()))
  37.     {
  38.         gInWord=FALSE;
  39.         StoreChar(ThisChar());
  40.         InputPlus(1);
  41.         return;
  42.     }
  43.     
  44.     oneChar=(ThisChar())|0x20;
  45.     
  46.     if ((oneChar=='i') && ((NextChar(1)|0x20)==(NextChar(2)|0x20)) &&
  47.         (IsConsonant(NextChar(1))) && ((NextChar(3)|0x20)=='e'))
  48.     {
  49.         gInWord=TRUE;
  50.         StoreChar(ThisChar()+'y'-'i');
  51.         StoreChar(NextChar(1));
  52.         StoreChar(NextChar(3));
  53.         InputPlus(4);
  54.         return;
  55.     }
  56.     
  57.     if ((oneChar=='i') && (IsConsonant(NextChar(1))) && ((NextChar(2)|0x20)=='e') &&
  58.         (!IsAlpha(NextChar(3))))
  59.     {
  60.         gInWord=TRUE;
  61.         StoreChar(ThisChar()+'y'-'i');
  62.         StoreChar(NextChar(1));
  63.         InputPlus(3);
  64.         return;
  65.     }
  66.     
  67.     if ((oneChar=='i') && ((NextChar(1)|0x20)=='c') && ((NextChar(2)|0x20)=='k') &&
  68.         (IsAlpha(NextChar(3))))
  69.     {
  70.         gInWord=TRUE;
  71.         StoreChar(ThisChar()+'y'-'i');
  72.         StoreChar(ThisChar()+'k'-'i');
  73.         InputPlus(3);
  74.         return;
  75.     }
  76.     
  77.     if ((oneChar=='i') && ((NextChar(1)|0x20)=='a') && (IsConsonant(NextChar(2))))
  78.     {
  79.         gInWord=TRUE;
  80.         StoreChar(ThisChar()+'e'-'i');
  81.         StoreChar(NextChar(2));
  82.         StoreChar(ThisChar()+'e'-'i');
  83.         InputPlus(3);
  84.         return;
  85.     }
  86.     
  87.     if ((oneChar=='e') && ((NextChar(1)|0x20)=='e') && (IsConsonant(NextChar(2))))
  88.     {
  89.         gInWord=TRUE;
  90.         StoreChar(ThisChar());
  91.         StoreChar(NextChar(2));
  92.         StoreChar(NextChar(1));
  93.         InputPlus(3);
  94.         return;
  95.     }
  96.     
  97.     if ((oneChar=='e') && ((NextChar(1)|0x20)=='a') && (IsConsonant(NextChar(2))))
  98.     {
  99.         gInWord=TRUE;
  100.         StoreChar(ThisChar());
  101.         StoreChar(NextChar(2));
  102.         StoreChar(ThisChar());
  103.         InputPlus(3);
  104.         return;
  105.     }
  106.     
  107.     if ((IsConsonant(oneChar)) && ((NextChar(1)|0x20)=='y'))
  108.     {
  109.         gInWord=TRUE;
  110.         StoreChar(ThisChar());
  111.         StoreChar(NextChar(1)+'e'-'y');
  112.         StoreChar(NextChar(1)+'e'-'y');
  113.         InputPlus(2);
  114.         return;
  115.     }
  116.     
  117.     if ((IsConsonant(oneChar)) && ((NextChar(1)|0x20)=='e') && ((NextChar(2)|0x20)=='r'))
  118.     {
  119.         gInWord=TRUE;
  120.         StoreChar(ThisChar());
  121.         StoreChar(NextChar(2));
  122.         StoreChar(NextChar(1));
  123.         InputPlus(3);
  124.         return;
  125.     }
  126.     
  127.     if ((IsVowel(oneChar)) && ((NextChar(1)|0x20)=='r') && ((NextChar(2)|0x20)=='e') &&
  128.         (!IsAlpha(NextChar(3))))
  129.     {
  130.         gInWord=TRUE;
  131.         StoreChar(ThisChar());
  132.         StoreChar(NextChar(1));
  133.         InputPlus(3);
  134.         return;
  135.     }
  136.     
  137.     if ((oneChar=='i') && ((NextChar(1)|0x20)=='a') && (IsConsonant(NextChar(2))))
  138.     {
  139.         gInWord=TRUE;
  140.         StoreChar(ThisChar());
  141.         StoreChar(NextChar(2));
  142.         StoreChar(ThisChar()+'e'-'o');
  143.         InputPlus(3);
  144.         return;
  145.     }
  146.     
  147.     if ((oneChar=='t') && ((NextChar(1)|0x20)=='i') && ((NextChar(2)|0x20)=='o') &&
  148.         ((NextChar(3)|0x20)=='n') && (!IsAlpha(NextChar(4))))
  149.     {
  150.         gInWord=TRUE;
  151.         StoreChar(ThisChar()+'c'-'t');
  152.         StoreChar(NextChar(1));
  153.         StoreChar(NextChar(2));
  154.         StoreChar(NextChar(2)+'u'-'o');
  155.         StoreChar(NextChar(3));
  156.         InputPlus(4);
  157.         return;
  158.     }
  159.     
  160.     if ((oneChar=='i') && ((NextChar(1)|0x20)=='o') && ((NextChar(2)|0x20)=='n'))
  161.     {
  162.         gInWord=TRUE;
  163.         StoreChar(ThisChar());
  164.         StoreChar(NextChar(1));
  165.         StoreChar(NextChar(1)+'u'-'o');
  166.         StoreChar(NextChar(2));
  167.         InputPlus(3);
  168.         return;
  169.     }
  170.     
  171.     if ((oneChar=='a') && ((NextChar(1)|0x20)=='i') && ((NextChar(2)|0x20)=='d'))
  172.     {
  173.         gInWord=TRUE;
  174.         StoreChar(ThisChar());
  175.         StoreChar(ThisChar()+'y'-'a');
  176.         StoreChar(NextChar(2));
  177.         StoreChar(NextChar(2)+'e'-'d');
  178.         InputPlus(3);
  179.         return;
  180.     }
  181.     
  182.     if ((oneChar=='a') && ((NextChar(1)|0x20)=='i'))
  183.     {
  184.         gInWord=TRUE;
  185.         StoreChar(ThisChar()+'e'-'a');
  186.         StoreChar(NextChar(1)+'y'-'i');
  187.         InputPlus(2);
  188.         return;
  189.     }
  190.     
  191.     if ((oneChar=='a') && ((NextChar(1)|0x20)=='y') && (!IsAlpha(NextChar(2))))
  192.     {
  193.         gInWord=TRUE;
  194.         StoreChar(NextChar(1));
  195.         InputPlus(2);
  196.         return;
  197.     }
  198.     
  199.     if ((oneChar=='a') && ((NextChar(1)|0x20)=='y'))
  200.     {
  201.         gInWord=TRUE;
  202.         StoreChar(ThisChar()+'e'-'a');
  203.         StoreChar(NextChar(1));
  204.         InputPlus(2);
  205.         return;
  206.     }
  207.     
  208.     if ((oneChar=='a') && ((NextChar(1)|0x20)=='n') && ((NextChar(2)|0x20)=='t'))
  209.     {
  210.         gInWord=TRUE;
  211.         StoreChar(ThisChar());
  212.         StoreChar(NextChar(1)+'u'-'n');
  213.         StoreChar(NextChar(1));
  214.         StoreChar(NextChar(2));
  215.         InputPlus(3);
  216.         return;
  217.     }
  218.     
  219.     if ((oneChar=='e') && ((NextChar(1)|0x20)=='a'))
  220.     {
  221.         gInWord=TRUE;
  222.         StoreChar(ThisChar());
  223.         StoreChar(NextChar(1)+'e'-'a');
  224.         InputPlus(2);
  225.         return;
  226.     }
  227.     
  228.     if ((oneChar=='o') && ((NextChar(1)|0x20)=='a'))
  229.     {
  230.         gInWord=TRUE;
  231.         StoreChar(ThisChar());
  232.         StoreChar(NextChar(1)+'o'-'a');
  233.         InputPlus(2);
  234.         return;
  235.     }
  236.     
  237.     if ((oneChar=='u') && ((NextChar(1)|0x20)=='e'))
  238.     {
  239.         gInWord=TRUE;
  240.         StoreChar(NextChar(1));
  241.         InputPlus(2);
  242.         return;
  243.     }
  244.     
  245.     if ((oneChar=='o') && ((NextChar(1)|0x20)=='e'))
  246.     {
  247.         gInWord=TRUE;
  248.         StoreChar(ThisChar());
  249.         InputPlus(2);
  250.         return;
  251.     }
  252.     
  253.     if ((oneChar=='o') && ((NextChar(1)|0x20)=='u'))
  254.     {
  255.         gInWord=TRUE;
  256.         StoreChar(ThisChar());
  257.         StoreChar(NextChar(1)+'w'-'u');
  258.         InputPlus(2);
  259.         return;
  260.     }
  261.     
  262.     if ((oneChar=='o') && ((NextChar(1)|0x20)=='w'))
  263.     {
  264.         gInWord=TRUE;
  265.         StoreChar(ThisChar());
  266.         StoreChar(NextChar(1)+'u'-'w');
  267.         InputPlus(2);
  268.         return;
  269.     }
  270.     
  271.     if ((!gInWord) && (oneChar=='h') && ((NextChar(1)|0x20)=='e'))
  272.     {
  273.         gInWord=TRUE;
  274.         StoreChar(ThisChar());
  275.         StoreChar(NextChar(1)+'i'-'e');
  276.         InputPlus(2);
  277.         return;
  278.     }
  279.     
  280.     if ((oneChar=='v') && ((NextChar(1)|0x20)=='e') && (!IsAlpha(NextChar(2))))
  281.     {
  282.         gInWord=TRUE;
  283.         StoreChar(ThisChar());
  284.         StoreChar(NextChar(1));
  285.         StoreChar(NextChar(1)+'t'-'e');
  286.         StoreChar(NextChar(1)+'h'-'e');
  287.         InputPlus(2);
  288.         return;
  289.     }
  290.     
  291.     if ((oneChar=='s') && ((NextChar(1)|0x20)=='e') && (!IsAlpha(NextChar(2))))
  292.     {
  293.         gInWord=TRUE;
  294.         StoreChar(ThisChar()+'e'-'s');
  295.         InputPlus(2);
  296.         return;
  297.     }
  298.     
  299.     if (((ThisChar()=='’') || (ThisChar()==0x27)) && ((NextChar(1)|0x20)=='s') &&
  300.         (!IsAlpha(NextChar(2))))
  301.     {
  302.         gInWord=TRUE;
  303.         StoreChar(NextChar(1)+'e'-'s');
  304.         StoreChar(NextChar(1));
  305.         InputPlus(2);
  306.         return;
  307.     }
  308.     
  309.     if ((oneChar=='i') && ((NextChar(1)|0x20)=='c') && (!IsAlpha(NextChar(2))))
  310.     {
  311.         gInWord=TRUE;
  312.         StoreChar(ThisChar());
  313.         StoreChar(NextChar(1));
  314.         StoreChar(NextChar(1)+'k'-'c');
  315.         InputPlus(2);
  316.         return;
  317.     }
  318.     
  319.     if ((oneChar=='i') && ((NextChar(1)|0x20)=='c') && ((NextChar(2)|0x20)=='s') &&
  320.         (!IsAlpha(NextChar(3))))
  321.     {
  322.         gInWord=TRUE;
  323.         StoreChar(ThisChar());
  324.         StoreChar(NextChar(1));
  325.         StoreChar(NextChar(2)+'c'-'s');
  326.         InputPlus(3);
  327.         return;
  328.     }
  329.     
  330.     if ((oneChar=='i') && ((NextChar(1)|0x20)=='c') && ((NextChar(2)|0x20)=='a') &&
  331.         ((NextChar(3)|0x20)=='l') && (!IsAlpha(NextChar(4))))
  332.     {
  333.         gInWord=TRUE;
  334.         StoreChar(ThisChar());
  335.         StoreChar(NextChar(1));
  336.         StoreChar(NextChar(2)+'k'-'a');
  337.         InputPlus(4);
  338.         return;
  339.     }
  340.     
  341.     if ((oneChar=='t') && ((NextChar(1)|0x20)=='l') && ((NextChar(2)|0x20)=='e') &&
  342.         (!IsAlpha(NextChar(3))))
  343.     {
  344.         gInWord=TRUE;
  345.         StoreChar(ThisChar());
  346.         StoreChar(NextChar(1)+'i'-'l');
  347.         StoreChar(NextChar(1));
  348.         InputPlus(3);
  349.         return;
  350.     }
  351.     
  352.     if ((oneChar=='l') && ((NextChar(1)|0x20)=='l') && (!IsAlpha(NextChar(2))))
  353.     {
  354.         gInWord=TRUE;
  355.         StoreChar(ThisChar());
  356.         InputPlus(2);
  357.         return;
  358.     }
  359.     
  360.     if ((oneChar=='o') && ((NextChar(1)|0x20)=='u') && ((NextChar(2)|0x20)=='l') &&
  361.         ((NextChar(3)|0x20)=='d') && (!IsAlpha(NextChar(4))))
  362.     {
  363.         gInWord=TRUE;
  364.         StoreChar(ThisChar());
  365.         StoreChar(NextChar(1));
  366.         StoreChar(NextChar(3));
  367.         StoreChar(NextChar(3)+'e'-'d');
  368.         InputPlus(4);
  369.         return;
  370.     }
  371.     
  372.     if ((oneChar=='o') && ((NextChar(1)|0x20)=='w') && ((NextChar(2)|0x20)=='n') &&
  373.         (!IsAlpha(NextChar(3))))
  374.     {
  375.         gInWord=TRUE;
  376.         StoreChar(ThisChar());
  377.         StoreChar(NextChar(1)+'u'-'w');
  378.         StoreChar(NextChar(2));
  379.         StoreChar(NextChar(2)+'e'-'n');
  380.         InputPlus(3);
  381.         return;
  382.     }
  383.     
  384.     if ((oneChar=='u') && ((NextChar(1)|0x20)=='n') && (!IsAlpha(NextChar(2))))
  385.     {
  386.         gInWord=TRUE;
  387.         StoreChar(ThisChar()+'o'-'u');
  388.         StoreChar(NextChar(1));
  389.         StoreChar(NextChar(1));
  390.         StoreChar(NextChar(1)+'e'-'n');
  391.         InputPlus(2);
  392.         return;
  393.     }
  394.     
  395.     if ((oneChar=='r') && ((NextChar(1)|0x20)=='r') && ((NextChar(2)|0x20)=='y') &&
  396.         (!IsAlpha(NextChar(3))))
  397.     {
  398.         gInWord=TRUE;
  399.         StoreChar(ThisChar());
  400.         StoreChar(NextChar(2));
  401.         StoreChar(NextChar(2)+'e'-'y');
  402.         InputPlus(3);
  403.         return;
  404.     }
  405.     
  406.     if ((oneChar=='e') && ((NextChar(1)|0x20)=='s') && ((NextChar(2)|0x20)=='t') &&
  407.         (!IsAlpha(NextChar(3))))
  408.     {
  409.         gInWord=TRUE;
  410.         StoreChar(ThisChar());
  411.         StoreChar(NextChar(1));
  412.         StoreChar(NextChar(2));
  413.         StoreChar(NextChar(2)+'e'-'t');
  414.         InputPlus(3);
  415.         return;
  416.     }
  417.     
  418.     if ((((oneChar=='p') && ((NextChar(1)|0x20)=='t')) ||
  419.         ((oneChar=='t') && ((NextChar(1)|0x20)=='h')) ||
  420.         ((oneChar=='c') && ((NextChar(1)|0x20)=='h')) ||
  421.         ((oneChar=='s') && ((NextChar(1)|0x20)=='s'))) && (!IsAlpha(NextChar(2))))
  422.     {
  423.         gInWord=TRUE;
  424.         StoreChar(ThisChar());
  425.         StoreChar(NextChar(1));
  426.         StoreChar(NextChar(1)+'e'-(NextChar(1)|0x20));
  427.         InputPlus(2);
  428.         return;
  429.     }
  430.     
  431.     if (((oneChar=='w') ||
  432.         (oneChar=='y') ||
  433.         (oneChar=='b') ||
  434.         (oneChar=='d') ||
  435.         (oneChar=='p')) && (!IsAlpha(NextChar(1))))
  436.     {
  437.         gInWord=TRUE;
  438.         StoreChar(ThisChar());
  439.         StoreChar(ThisChar()+'e'-oneChar);
  440.         InputPlus(1);
  441.         return;
  442.     }
  443.     
  444.     if (((oneChar=='r') ||
  445.         (oneChar=='n') ||
  446.         (oneChar=='t')) && (!IsAlpha(NextChar(1))))
  447.     {
  448.         gInWord=TRUE;
  449.         StoreChar(ThisChar());
  450.         StoreChar(ThisChar());
  451.         StoreChar(ThisChar()+'e'-oneChar);
  452.         InputPlus(1);
  453.         return;
  454.     }
  455.     
  456.     if ((!gInWord) && (oneChar=='f') && ((NextChar(1)|0x20)=='r') &&
  457.         ((NextChar(2)|0x20)=='o') && ((NextChar(3)|0x20)=='m') && (!IsAlpha(NextChar(4))))
  458.     {
  459.         gInWord=TRUE;
  460.         StoreChar(ThisChar());
  461.         StoreChar(NextChar(1));
  462.         StoreChar(NextChar(2));
  463.         InputPlus(4);
  464.         return;
  465.     }
  466.     
  467.     if ((!gInWord) && (oneChar=='w') && ((NextChar(1)|0x20)=='h') &&
  468.         ((NextChar(2)|0x20)=='e') && ((NextChar(3)|0x20)=='n') && (!IsAlpha(NextChar(4))))
  469.     {
  470.         gInWord=TRUE;
  471.         StoreChar(ThisChar());
  472.         StoreChar(NextChar(1));
  473.         StoreChar(NextChar(2)+'a'-'e');
  474.         StoreChar(NextChar(3));
  475.         InputPlus(4);
  476.         return;
  477.     }
  478.     
  479.     gInWord=TRUE;
  480.     StoreChar(ThisChar());
  481.     InputPlus(1);
  482. }
  483.